home *** CD-ROM | disk | FTP | other *** search
/ boe.pres.k12.wv.us / boe.pres.k12.wv.us.zip / boe.pres.k12.wv.us / Utilities / Xerox Workcentre 5335 / Windows Scan / 64-bit_x64 / Russian / cpsimage.cab / data / xipsup.ucm < prev   
Text File  |  2009-04-23  |  27KB  |  500 lines
  1. #
  2. # XIPIMAGE Object and support objects for ELF interpreter
  3. #
  4. # M.Campanelli
  5. # May 2004
  6. #
  7. # For a description of how this file works, see Appendix C of 
  8. # Architecture document at XIPS web page.
  9. # http://codex.xerox.com/projects/xips or
  10. # http://xin.xeroxlabs.com/xips
  11. #
  12.  
  13. <DESCRIPTION>
  14. desc: This file contains the basic object descriptions for connecting XEngine/XFlow image processing \
  15.       technology with the ELF interpreter.  These descriptions are used by the interpreter to \
  16.       define objects and methods the interpreter can use.  It is also used to code generate \
  17.       compilable code which improves the interpreters performance. This file also contains a set a \
  18.       small set of static function declarations that have there own descriptions.  \
  19.       Simply follow the links.
  20.  
  21.  
  22. <OBJECTS>
  23.  
  24. [XIPCOLOR]
  25. public:  c             INTEGER ARRAY      Desc=Separation values
  26. public:  photometry    INTEGER            Desc=Photometry values
  27. method:  getSeps       Native=XIPCOLORMethods@xipsup \
  28.                        Output=seps.INTEGER \
  29.                        Desc=Return number of seps for this color photometry
  30. desc: {
  31. // DESCRIPTION
  32.    A XIPCOLOR object holds color information for XIPLAYER's. Layer types XIP_ContoneMask,
  33. XIP_ColorMask, and XIP_ColorRectangle will have information about the color in the layer.
  34. The 'c' member is typically an array of 1 to 4 values; 1 sep gray, 3 seps color, 4 is CMYK.
  35. You can set or get these values as shown in the following examples;
  36.  
  37. XIPCOLOR color = new (XIPCOLOR, c: (128, 234, 45, 200), photometry: XIP_CMYK_COLOR);
  38.  
  39. or, if never set or doing a total overwrite,
  40.  
  41. color.c = (128, 234, 45, 200);
  42.  
  43. or, if the array exists, i.e., has already been initialized,
  44.  
  45. color.c[0] = 128;
  46. color.c[1] = 234;
  47. ...
  48.  
  49. Note, if the object starts as a simple declaration the 'c' array will be NULL. In this
  50. case you need to initialize it via the LIST assignment, i.e., xx = (xx, xx, xx, xx), which
  51. serves as an array allocation.
  52.  
  53. The following demonstrates Getting values from the object;
  54.  
  55. INTEGER i1 = color.c[0];
  56. INTEGER i2 = color.c[1];
  57. ...
  58.  
  59. You can also locally capture the array as a LIST, e.g.,
  60. LIST l = color.c;
  61. print l;
  62. }
  63.  
  64.  
  65. [XIPHDR]
  66. private:  pad           INTEGER ARRAY     Desc=padding bytes/scanLines
  67. private:  compression   INTEGER           Desc=compression type
  68. private:  interleave    INTEGER           Desc=interleave Scan=0, Pix=1, Frame=2
  69. private:  photometry    INTEGER           Desc=color space photometry
  70. private:  seps          INTEGER           Desc=separations in image
  71. private:  bytes         INTEGER ARRAY     Desc=bytes/scanLines
  72. private:  bits          INTEGER ARRAY     Desc=bits/pixel in image
  73. private:  scanlines     INTEGER           Desc=scanlines in images
  74. private:  pixels        INTEGER           Desc=pixels in image
  75. private:  format        INTEGER           Desc=image data type, i.e., XEngine\
  76.                                                or Pixr
  77. private:  endianType    INTEGER           Desc=byte order of image data
  78. private:  border        INTEGER           Desc=Width of processing frame around\
  79.                                               image, usually Pixr formats
  80. private:  alignment     INTEGER           Desc=alignment of image data
  81. private:  clientData    "struct _ELFLIST*" Desc=Holds arbitrary client data
  82. private:  extraData     "void* private"   Desc=Holds arbitrary header data
  83.  
  84.  
  85. [XIPTEXT]
  86. private: format         INTEGER           Desc=tells what type of formatting \
  87.                                           the data is in
  88. private: charCount      INTEGER           Desc=tells number of characters
  89. private: qcharCount     INTEGER           Desc=tells number of questionable characters
  90. private: ucharCount     INTEGER           Desc=tells number of unrecognized characters
  91. private: wordCount      INTEGER           Desc=tells number of words counted
  92. private: render         BOOLEAN           Desc=Do we flatten into the image or \
  93.                                           not. This means that the text become \
  94.                                           rasterized.
  95.  
  96.  
  97. [XIPLAYER]
  98. public:  mediaColor    XIPCOLOR           Desc=Background color, only for Contone
  99. public:  color         XIPCOLOR           Desc=Layer color, only for \
  100.                                           ColorMask and ColorRectangle
  101. public:  layerType     INTEGER            Desc=See defined constants for types
  102. public:  ypos          DOUBLE             Desc=Location wrt original image
  103. public:  xpos          DOUBLE             Desc=Location wrt original image
  104. public:  height        DOUBLE             Desc=Height of layer object
  105. public:  width         DOUBLE             Desc=Width of layer object
  106. public:  yres          DOUBLE             Desc=Original image y resolution
  107. public:  xres          DOUBLE             Desc=Original image x resolution
  108. public:  opacity       DOUBLE             Desc=Object opacity, zero to one
  109. public:  rotation      DOUBLE             Desc=Set layer rotation
  110. public:  visibility    BOOLEAN            Desc=Is this layer visible, def; TRUE
  111. private: text          "struct _ELFXIPTEXT*" Desc=Value field for Text layer
  112. private: hdr           "struct _ELFXIPHDR*"  Desc=Holds raster data parameters
  113. private: data          "struct _ELFPOINTER*" Desc=ptr to data, image or other
  114. private: clientData    "struct _ELFLIST*" Desc=Holds arbitrary client data
  115.  
  116. # items below are to administer layer processing
  117. private: flags         INTEGER            Desc=private flags
  118. private: memoryNode    INTEGER            Desc=Does this object have a xipWriteMem \
  119.                                           node set, 0=no, 1=yes
  120. private: outputNum     INTEGER            Desc=output number for XFlow process
  121. private: outputLinks   INTEGER            Desc=outputs connected to this node
  122. private: xfhandle      "void* private"    Desc=XFlow XEngine handle
  123. private: parentObj     "struct _ELFOBJECT*" Desc=Ptr to parent object
  124. private: arglist       "struct _ELFLIST*" Desc=arguments for the desired cmd
  125. private: NODE_ID       INTEGER            Desc=XFLow node ID
  126. private: attributes    "struct _ELFLIST*" Desc=General purpose stuff
  127. method:  toImg         Native=XIPMethods@xipsup \
  128.                        Output=img.XIPIMAGE \
  129.                        Desc=!XIPLayer2XIPIMAGE Upgrade the XIPLAYER to an \
  130.                        XIPIMAGE object
  131. method:  setAttr       Native=XIPMethods@xipsup \
  132.                        Input=name.STRING, num.i, obj.OBJECT \
  133.                        Desc=!XIPAttributes Set named parameters into the object \
  134.                        attributes. If the name is already there, it will be \
  135.                        replaced with the new value.
  136. method:  getAttr       Native=XIPMethods@xipsup \
  137.                        Input=name.STRING, num.i \
  138.                        Output=obj.OBJECT \
  139.                        Desc=!XIPAttributes Get the named attribute. If no name \
  140.                        is passed in, the entire list is returned;
  141. method:  clearAttr     Native=XIPMethods@xipsup \
  142.                        Input=name.STRING, num.i \
  143.                        Desc=!XIPAttributes Clear the named attribute. If no \
  144.                        name is passed in, the entire list is removed;
  145.  
  146.  
  147. [XIPIMAGE]
  148. public:  info          STRING             Desc=General purpose information string
  149. public:  imageWidth    INTEGER            Desc=Original image width
  150. public:  imageHeight   INTEGER            Desc=Original image height
  151. public:  resolution    DOUBLE ARRAY       Desc=Original image resolution
  152. public:  nlayers       INTEGER            Desc=How many layers does it have
  153. # public:  layers        ELFLIST            Desc=List of layers
  154. private: layers        "struct _ELFLIST*" Desc=List of layers
  155. private: other         "struct _ELFPOINTER*" Desc=other data
  156. private: xipservice    "void* private"    Desc=XIPService structure
  157. private: clientData    "struct _ELFLIST*" Desc=Client data
  158. private: attributes    "struct _ELFLIST*" Desc=General purpose stuff
  159. method:  getSize       Native=XIPMethods@xipsup \
  160.                        Output=size.INTEGER \
  161.                        Desc=Returns the size in bytes of the object. This \
  162.                        includes all data held by the object. It does not \
  163.                        include header information. Depending on the output, \
  164.                        take the nlayers value and multiply by an adjustment \
  165.                        factor.
  166. method:  setAttr       Native=XIPMethods@xipsup \
  167.                        Input=name.STRING, num.i, obj.OBJECT \
  168.                        Desc=!XIPAttributes Set named parameters into to object \
  169.                        attributes. If the name is already there, it will be \
  170.                        replaced with the new value.
  171. method:  getAttr       Native=XIPMethods@xipsup \
  172.                        Input=name.STRING, num.i \
  173.                        Output=obj.OBJECT \
  174.                        Desc=!XIPAttributes Get the named attribute. If no name \
  175.                        is passed in, the entire list is returned;
  176. method:  clearAttr     Native=XIPMethods@xipsup \
  177.                        Input=name.STRING, num.i \
  178.                        Desc=!XIPAttributes Clear the named attribute. If no \
  179.                        name is passed in, the entire list is removed;
  180. method:  getMember     Native=XIPMethods@xipsup \
  181.                        Input=section.STRING, member.STRING, mindex.i, num.i Output=value.OBJECT \
  182.                        Desc=!XIPMethod_get Return the value of the nth \
  183.                        layer XIPLAYER member requested.  If no layer exists \
  184.                        nothing is returned.
  185. method:  setMember     Native=XIPMethods@xipsup \
  186.                        Input=member.STRING, num.i, value.OBJECT \
  187.                        Desc=!XIPMethod_set sets the member value of the nth \
  188.                        layer XIPLAYER.  If no layer exists nothing is set.
  189. method:  getLayer      Native=XIPMethods@xipsup \
  190.                        Input=num.INTEGER Output=img.XIPIMAGE \
  191.                        Desc=Return an XIPIMAGE if the layer exists. Layers \
  192.                        are indexed with zero reference.
  193. method:  exec          Native=XIPMethods@xipsup \
  194.                        Input=save.STRING, perfLog.s, perfLevel.i, watchdog.i \
  195.                        Output=img.XIPIMAGE \
  196.                        Desc=Execute deferred image path workflow to the \
  197.                        current point.
  198. method:  unCompress    Native=XIPMethods@xipsup \
  199.                        Input=type.INTEGER, binarytype.BOOLEAN, contonetype.BOOLEAN \
  200.                        Output=img.XIPIMAGE \
  201.                        Desc=!__xipsUnCompress General decompression selection
  202. method:  compress      Native=XIPMethods@xipsup \
  203.                        Input=type.STRING, profile.i, quality.i, jquality.i, \
  204.                        sample.LIST, binarytype.STRING, contonetype.STRING, \
  205.                        lossless.BOOLEAN, force.BOOLEAN \
  206.                        Output=img.XIPIMAGE \
  207.                        Desc=!__xipsCompress General compression selection
  208. method:  addLayer      Native=XIPMethods@xipsup \
  209.                        Input=image.OBJECT, lindex.i, ltype.i, \
  210.                        width.DOUBLE, height.DOUBLE, xpos.DOUBLE, ypos.DOUBLE, \
  211.                        color.XIPCOLOR, mediaColor.XIPCOLOR \
  212.                        Output=img.XIPIMAGE \
  213.                        Desc=!XIPMethod_addLayer Add the layer from the input \
  214.                        image at lindex to the parent XIPIMAGE object. The \
  215.                        input image can be either a XIPIMAGE or XIPLAYER
  216. method:  deleteLayer   Native=XIPMethods@xipsup \
  217.                        Input=num.i, name.s \
  218.                        Output=img.XIPIMAGE \
  219.                        Desc=!XIPDeleteLayer Delete the specified layer from the input image
  220. method:  setTransform  Native=XIPLazyOp@xipsup \
  221.                        Input=op.STRING, factor.d, upi.d, posx.d, posy.d, \
  222.                              width.d, height.d, orient.s, std.s, angle.d, mode.s \
  223.                        Output=img.XIPIMAGE \
  224.                        Desc=Set transform information for the object. Operations \
  225.                        can be rotate, scale, position, or center. Note that this \
  226.                        alters the image and layer parameters in place, a copy of \
  227.                        the image is not made.
  228. method:  seq2imageList Native=XIPMethods@xipsup \
  229.                        Input=lindex.i \
  230.                        Output=list.LIST \
  231.                        Desc=!__XIPMethod_seq2list Convert an image sequence \
  232.                        layer into an LIST of discrete XIPIMAGE objects.
  233. desc: {
  234. // DESCRIPTION
  235.   The XIPIMAGE object can be thought of as analogous to a page.  Just as a page can be made up
  236. of several objects, so too a XIPIMAGE can hold one to many layers with different layer types; see
  237. Defined Contants for the LayerTypes allowed.
  238.  
  239.   In general, the methods of a XIPIMAGE mean that the input to this object is at least one XIPIMAGE;
  240. some methods will take more than one image in.  The output will very between a XIPIMAGE, XIPINFO object,
  241. or nothing at all.  In the latter case the final node is terminal, as in writers.
  242.  
  243.   The processing model is deferred where possible. The reason for this is to maintain performance. Where
  244. possible, execution of an existing deferred group may have to be resolved to provide information.  In 
  245. some cases it is not always detectable.  For non terminal nodes you can always force the resolution via
  246. the exec() method.  For ex.,
  247.  
  248.   XIPIMAGE img = readimage (filename: myfile).cspace (outspace: "gray").exec();
  249.  
  250. The value of img will be fully realized after this statement because of the exec() method.  If a list
  251. of deferred operations are terminal, then you can use the static function Execute ().  This will
  252. resolve any terminal deferred processes.  For ex.,
  253.  
  254.   img.display  (title: myfile);
  255.   img.writepng (filename: myfile.name() + ".png");
  256.   img.writetif (filename: myfile.name() + ".tif");
  257.   img.writebmp (filename: myfile.name() + ".bmp");
  258.   Execute ();
  259.  
  260. All these operations are deferred until the Execute () or the end of the script.  As a final warning,
  261. situations have come up where within a script a file is consumed, processed, written to disc, then
  262. tried to be consumed again.  The problem here is the deferred processing, unless and Execute() is 
  263. used before trying to re-consume the output it may not exist.
  264. }
  265.  
  266.  
  267.  
  268. [XIPINFO]
  269. public:  name          STRING               DESC=Name of the module that produced this object
  270. private: data          "struct _ELFPOINTER*" Desc=Attach XEngine info data here
  271. private: infofields    "void* private"      Desc=XEngine XEngInfoFields
  272. private: hdr           "void* private"      Desc=XEngine XEngHeaderStruct
  273. private: xfhandle      "void* private"      Desc=XFlow XEngine handle
  274. private: parentObj     "void* private"      Desc=Ptr to parent object
  275. private: arglist       "struct _ELFLIST*"   Desc=arguments for the desired cmd
  276. private: outputLinks   INTEGER              Desc=outputs connected to this node
  277. private: flags         INTEGER              Desc=private flags
  278. private: memoryNode    INTEGER              Desc=Does this object have a \
  279.                                             xipWriteMem node set, 0=no, 1=yes
  280. private: bytes         INTEGER              Desc=bytes per entry
  281. private: entries       INTEGER              Desc=number of entries
  282. private: NODE_ID       INTEGER              Desc=XFlow node ID
  283. method:  getEntryCount Native=XIPINFOMethods@xipsup \
  284.                        Output=count.INTEGER \
  285.                        DESC=Gets the number of entries in the XIPINFO object
  286. method:  getFieldCount Native=XIPINFOMethods@xipsup \
  287.                        Output=count.INTEGER \
  288.                        DESC=Gets the number of fields associated with an entry
  289. method:  findField     Native=XIPINFOMethods@xipsup \
  290.                        Input=name.STRING, type.STRING \
  291.                        Output=field.INTEGER \
  292.                        DESC=Finds a given field and returns the index position of the field, zero \
  293.                        reference. The \"type\" value is one of the basic types, i.e., i, s, f for \
  294.                        INTEGER, STRING, DOUBLE
  295. method:  getFieldName  Native=XIPINFOMethods@xipsup \
  296.                        Input=field.INTEGER \
  297.                        Output=name.STRING \
  298.                        DESC=Gets the name of the given field at the field index position
  299. method:  getFieldType  Native=XIPINFOMethods@xipsup \
  300.                        Input=field.INTEGER \
  301.                        Output=type.STRING \
  302.                        DESC=Gets the type of the given field at the field index position
  303. method:  getFieldSize  Native=XIPINFOMethods@xipsup \
  304.                        Input=field.INTEGER \
  305.                        Output=size.INTEGER \
  306.                        DESC=Gets the size of the given field at the field index position
  307. method:  getFieldInt   Native=XIPINFOMethods@xipsup \
  308.                        Input=entry.INTEGER, index.INTEGER, field.INTEGER \
  309.                        Output=value.INTEGER \
  310.                        DESC=Gets the index of the given field for the given entry. For ex, if \
  311.                        the field \"parts\" typically has 3 values.  The \"index\" \
  312.                        would be 0, 1, 2 respectively to access them.
  313. method:  getFieldDouble Native=XIPINFOMethods@xipsup \
  314.                        Input=entry.INTEGER, index.INTEGER, field.INTEGER \
  315.                        Output=value.DOUBLE \
  316.                        DESC=Gets the index of the given field for the given entry; similar \
  317.                        to getFieldInt
  318. method:  getFieldStr   Native=XIPINFOMethods@xipsup \
  319.                        Input=entry.INTEGER, field.INTEGER \
  320.                        Output=value.STRING \
  321.                        DESC=Gets the given field for the given entry; similar to getFieldInt but\
  322.                        without an index
  323. method:  getFieldList  Native=XIPINFOMethods@xipsup \
  324.                        Input=entry.INTEGER, field.INTEGER \
  325.                        Output=value.LIST \
  326.                        DESC=Gets the given field for the given entry. It will return the entire\
  327.                        field in a list.
  328. method:  toString      Native=XIPINFOMethods@xipsup \
  329.                        Output=output.STRING \
  330.                        DESC=Converts all the XIPINFO data to a single string
  331. method:  seq2infoList  Native=XIPMethods@xipsup \
  332.                        Output=list.LIST \
  333.                        Desc=!__XIPMethod_seq2infoList Convert XIPINFO sequence \
  334.                        into an LIST of discrete XIPINFO objects.
  335. method:  exec          Native=XIPMethods@xipsup \
  336.                        Input=save.STRING, perfLog.s, perfLevel.i, watchdog.i \
  337.                        Output=info.XIPINFO \
  338.                        Desc=Execute the image path workflow to get the \
  339.                        output info object.
  340. desc: {
  341. // DESCRIPTION
  342.    The XIPINFO object is alternative content data returned from XEngines.  Its methods access this data.
  343. XEngine Info Objects are a flat structure layout used by XEngines to return non-image data.  The info data
  344. pseudo header contains information about the Entries and fields within the Entries.  With these methods
  345. all information can be programmatically accessed.
  346.  
  347. // EXAMPLE using orient_page module
  348. XIPINFO orient = readimage (filename: infile).orient_page();
  349.  
  350. // Quick way to see all the content of the info
  351. print orient.toString ();
  352.  
  353. INTEGER i = orient.findField (name: "direction", type: "i");
  354. print "direction index = " + i;
  355. INTEGER dir = orient.getFieldInt (entry: 0, index:0, field: i);
  356. print "Direction is " + dir;
  357.  
  358. i = orient.findField (name: "confidence", type: "i");
  359. print "confidence index = " + i;
  360. INTEGER con = orient.getFieldInt (entry: 0, index:0, field: i);
  361. print "Confidence is " + con;
  362.  
  363.  
  364. An alternative way to see info content is with the "pex" command line application.  For any XEngine module
  365. that returns an info object you execute the command line with pex.  The example below is for orient_page;
  366.  
  367. > pex readimage someImageFile : orient_page : dump
  368. Info size:  <undefined>
  369. Info blobs: <undefined>
  370. Entries [s c]: 0 <all>
  371. Info fields:
  372.     direction: integer - 4 bytes
  373.     confidence: integer - 4 bytes
  374.  
  375. Blob 0:
  376.  sl\px
  377. ------
  378. Entry 0:
  379. direction: 0
  380. confidence: 0
  381.  
  382. If instead of orient_page one used histogram, you get the following;
  383.  
  384. > pex readimage someImageFile : histogram : dump
  385. Info size: 3 entries
  386. Info blobs: <undefined>
  387. Entries [s c]: 0 <all>
  388. Info fields:
  389.     separation: integer - 4 bytes
  390.     bits: integer - 4 bytes
  391.     style: string - 32 bytes
  392.     histogram: 256 integers - 1024 bytes
  393.  
  394. Blob 0:
  395.  sl\px
  396. ------
  397. Entry 0:
  398. separation: 1
  399. bits: 8
  400. style: "normalized"
  401. histogram: 0 0 0 77 717 2425 3665 5797 3407 3 2894 2936 2340 1946 1668 1313 1586 1264 1153 1191 1126 1017 873 832 1352 803 633 284 739 582 986 529 912 445 867 387 785 657 348 647 643 341 565 623 540 201 190 546 610 526 549 270 459 557 542 593 527 510 495 454 491 487 495 290 292 475 472 502 488 462 433 480 486 434 496 449 571 684 426 426 333 202 283 348 526 595 400 395 350 491 560 396 353 313 496 539 387 349 287 414 326 255 318 378 597 355 309 432 542 313 428 503 315 277 491 483 304 492 198 210 613 692 332 464 950 487 459 877 593 530 640 618 835 522 368 822 553 138 486 785 390 605 643 697 694 303 553 562 571 633 251 465 609 481 479 138 290 525 543 614 300 707 324 545 544 588 596 321 790 313 789 281 543 181 349 549 415 552 289 728 316 765 347 834 349 868 392 785 407 562 429 619 163 271 805 357 907 238 980 192 1009 183 1035 161 1052 149 1090 109 1279 92 850 70 1218 107 1623 119 1914 172 2969 252 1822 522 1103 1114 347 1213 83 1162 59 432 30 605 76 513 118 421 172 104 245 32 318 21 278 37 399 82 471 114 83 408 45 515 21 1722 0 2500
  402.  
  403. Entry 1:
  404. separation: 2
  405. bits: 8
  406. style: "normalized"
  407. ...
  408.  
  409.  
  410. // This is how you would access the 11th value of the "histogram" field of "Entry 0" via script;
  411.  
  412. XIPINFO hist = readimage (filename: infile).histogram();
  413. INTEGER i    = hist.findField (name: "histogram", type: "i");
  414. print hist.getFieldInt (entry: 0, index:10, field: i);
  415. // output is
  416. 2894
  417.  
  418.  
  419. There are many modules that output XIPINFO objects, see the return types for XIPIMAGE methods to be sure of
  420. the return type.
  421. }
  422.  
  423.  
  424. [XIPTIMER]
  425. public: startTime      DOUBLE           Desc=Start time of timer
  426. public: markTime       DOUBLE           Desc=Last time elapsed method called
  427. public: lapTime        DOUBLE           Desc=Time elapsed since last call of elapsed method
  428. public: splitTime      DOUBLE           Desc=Time elapsed since timer was started
  429. public: running        BOOLEAN          Desc=Current state of timer
  430. method: start          Native=XIPTIMERMethods@xipsup \
  431.                        Output=obj.XIPTIMER \
  432.                        Desc=Start the timer
  433. method: stop           Native=XIPTIMERMethods@xipsup \
  434.                        Desc=Stop the timer.
  435. method: reset          Native=XIPTIMERMethods@xipsup \
  436.                        Desc=Reset the timer
  437. method: elapsed        Native=XIPTIMERMethods@xipsup \
  438.                        Input=lap.BOOLEAN \
  439.                        Output=time.DOUBLE \
  440.                        Desc=!XIPTIMERMethods Returns lap or split time in \
  441.                        seconds. If lap is TRUE, it returns lap time. If lap \
  442.                        is FALSE or not specified, it returns split time.
  443.  
  444.  
  445.  
  446. <FUNCTIONS>
  447.  
  448. function: Execute      Native=GraphExecute@xipsup \
  449.                        Input=save.s, perfLog.s, perfLevel.i, watchdog.i \
  450.                        DESC=!GraphExecute Execute the current state.  Resolves all differed \
  451.                        processing for image processing connections that end with a terminal \
  452.                        node, e.g., writexxx.
  453.  
  454. function: LoadClasses  Native=LoadClasses@xipsup \
  455.                        Input=filename.s, list.LIST, \
  456.                        exlist.LIST, dynamicObjs.i \
  457.                        DESC=Loads XEngine modules as static functions and objects, or methods \
  458.                        of XIPIMAGE object. The \"filename\" is the library name of a dynamically \
  459.                        registerable XEngine library.
  460.  
  461. function: MD5          Native=XIPSMD5@xipsup Input=filename.STRING, obj.OBJECT  \
  462.                        Output=str.STRING \
  463.                        Desc=Implementation of Message Digest algorithm 5 to CRC. Widely used \
  464.                        cryptographic hash function with a 128-bit hash value.  The value is \
  465.                        returned as hex values printed to a STRING object.
  466.  
  467. function: SHA1         Native=XIPSSHA1@xipsup Input=filename.STRING, \
  468.                        str.STRING, obj.OBJECT  \
  469.                        Output=str.STRING \
  470.                        Desc=Implementation of Secure Hash Algorithm 1, a \
  471.                        cryptographic hash function with a 160-bit hash value. \
  472.                        The value is returned as base64 value printed to a \
  473.                        STRING object.
  474.  
  475. function: ReadObject   Native=ReadObject@xipsup \
  476.                        Input=filename.STRING, override.i  \
  477.                        Output=this.OBJECT
  478.  
  479. function: ReadIMS      Native=XIPReadIMS@xipsup \
  480.                        Input=filename.STRING, list.BOOLEAN, deferred.BOOLEAN \
  481.                        Output=img.OBJECT
  482.  
  483. function: WriteIMS     Native=XIPWriteIMS@xipsup \
  484.                        Input=filename.STRING, img.XIPIMAGE
  485.  
  486. function: ScriptExec   Native=ScriptExec@xipsup \
  487.                        Input=filename.s, import.LIST, export.LIST \
  488.                        Output=userdef.OBJECT \
  489.                        DESC=!ScriptExec Execute a script
  490.  
  491. function: System       Native=ELFSystem@xipsup \
  492.                        Input=cmd.STRING, mode.STRING \
  493.                        Output=obj.OBJECT \
  494.                        DESC=!ELFSystem Execute a system call
  495.  
  496. function: TimeCheck    Native=XIPSTimeChk@xipsup \
  497.                        Output=time.s \
  498.                        DESC=!XIPSTimeChk Returns a string with the current \
  499.                        execution time relative to the start of XIPSExecute.
  500.